package com.company.day10;

import org.omg.PortableServer.ForwardRequest;

import javax.swing.*;
import java.security.cert.TrustAnchor;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * @description:
 * @author: Code-zyc
 * @date: Created in 2021/9/2 19:15
 * @version: 1.0
 * @modified By:
 */
public class Likou {
    public static void main(String[] args) {

        int nums[] = new int[]{1,3,5,6};

        System.out.println(searchInsert(nums,2));

    }

    public static int searchInsert(int[] nums, int target) {

        // 最大索引
        int maxIndex = nums.length -1;
        // 最小索引
        int minIndex = 0;
        // 中间索引
        int halfIndex = minIndex+(maxIndex-minIndex)/2;

        while (minIndex<=maxIndex){
            // 找到时
            if (nums[halfIndex]==target){
                return halfIndex;
            }else if (nums[halfIndex]<target){// 比target小时
                minIndex = halfIndex + 1;
            }else {// 比target大时
                maxIndex = halfIndex - 1;
            }
            halfIndex = minIndex+(maxIndex-minIndex)/2;
        }
       return  maxIndex +1;

    }

    public static int pivotIndex(int[] nums){
        int sum=0;
        for (int i = 0; i < nums.length; i++) {
            sum=sum+nums[i];
        }
        int left=0;
        for (int i = 0; i < nums.length; i++) {
            if(sum-nums[i]==2*left){
                return i;
            }
            left=left+nums[i];
        }
        return -1;
    }


    public static int pivotIndex2(int[] nums) {
        int length = nums.length;
        int mid = length / 2;  //选中中间的作为一开始的比较
        int left = 0, right = 0;
        boolean flag = true; //true  代表上一次 是 左移  false 代表是右移
        //计算左边的值
        for (int i = 0; i < mid; i++) {
            left = left + nums[i];
        }
        //计算右边的值
        for (int i = length - 1; i > mid; i--) {
            right = right + nums[i];
        }

        //进行主要循环
        while (true) {
            //如果相等 或者mid 这个游标超出了范围 贼退出
            if (left == right || mid <= 0 || mid >= length - 1) {
                break;
            }
            //首先计算 游标得左右移动得收益（这个收益是针对  左边来说的）

            //列子： 27 -10 2  5 5 5   游标初始  在2   左边 17  右边15  左边大 右边小
            // 此时游标 右移动 左边+2  右边 -5 对于左边就是+5  收益  7
            int rightmove = nums[mid] + nums[mid + 1];
            //此时游标 左移 左边 - -10  右边 +2 对于左边 -2  收益：8
            int leftmove = -nums[mid - 1] - nums[mid];
            //这个收益就可以决定 如果 左边大于右边  应该左边小 右边大  那就 选收益小的移动
            //具体看下面解释


            //如果左边大于右边
            if (left > right) {

                //判断
                //如果右移动收益大于左移动收益 而此时应该 减少左边 增加右边  那就向收益少的移动
                if (rightmove > leftmove) {
                    left = left - nums[mid - 1];
                    right = right + nums[mid];
                    mid--;
                    flag = true;
                }

                if (rightmove < leftmove) {
                    left = left + nums[mid];
                    right = right - nums[mid + 1];
                    mid++;
                    flag = false;
                }

                if (rightmove == leftmove) {
                    if (flag) {
                        left = left - nums[mid - 1];
                        right = right + nums[mid];
                        mid--;
                        flag = true;
                    } else {

                        left = left + nums[mid];
                        right = right - nums[mid + 1];
                        mid++;
                        flag = false;

                    }

                }


                //如果移动了 左边小于右边 那就证明无解了
                if (left < right) {
                    break;
                }
            }
            //如果左边小于右边
            if (left < right) {

                //判断
                //如果右移动收益大于左移动收益 而此时应该 增大左边 减小右边  那就向收益多的移动
                if (rightmove > leftmove) {
                    left = left + nums[mid];
                    right = right - nums[mid + 1];
                    mid++;
                    flag = false;
                }

                if (rightmove == leftmove) {
                    if (flag) {
                        left = left - nums[mid - 1];
                        right = right + nums[mid];
                        mid--;
                        flag = true;
                    } else {

                        left = left + nums[mid];
                        right = right - nums[mid + 1];
                        mid++;
                        flag = false;

                    }

                }

                if (rightmove < leftmove) {
                    left = left - nums[mid - 1];
                    right = right + nums[mid];
                    mid--;
                    flag = true;

                }
                //如果移动了 左边大于右边 那就证明无解了
                if (left > right) {
                    break;
                }
            }

        }
        //进行判断 看看是正确的情况退出循环  还是 无解的情况下退出的循环
        if (left == right) {
            return mid;
        } else {
            return -1;
        }

    }


    public static int removeDuplicates(int[] nums) {
        int size = 0;
        if (nums.length != 0) {
            size++;
            Arrays.sort(nums);

        }

        for (int i = 0; i < nums.length - 1; i++) {

            if (nums[i] != nums[i + 1]) {
                nums[size] = nums[i + 1];
                size++;

            }
        }
        return size;
    }
}
